﻿//using System;
//using System.Collections.Generic;
//using System.Text;
//using System.Collections.Specialized;
//using System.Web;
//using System.IO;
//using Openlab.Common;
//using LoggerUtility;
//using Wwtfly.AttachmentUtillity.Ftp;


//namespace Wwtfly.AttachmentUtillity.Attachment
//{
//   public class FtpCRMAttachmentProvider : AttachmentProvider
//    {
//        public string _AttachmentServerUrl;
//        private string _downLoadTempDir = "~/Temp";
//        public string _ftpPassword;
//        public int _ftpPort = 21;
//        public string _ftpServer;
//        public int _ftpTimeOut = 300;
//        public string _ftpUserName;
//        public string _transferMode = "Pasv";
//        public string _ftpEncoder = "Default";
//        private string m_AttachmentMappingPath;
//        private string m_User;

//        public FtpCRMAttachmentProvider()
//        {
//        }


//        /// <summary>
//        /// 用户名
//        /// </summary>
//        /// <param name="userName"></param>
//        public FtpCRMAttachmentProvider(string userName)
//        {
//            m_User = userName;
//            m_AttachmentMappingPath = "";
//        }

//        public override string UserName
//        {
//            get { return m_User; }
//            set { m_User = value; }
//        }

//        /// <summary>
//        /// FTP服务器地址
//        /// </summary>
//        public string FtpServer
//        {
//            get { return _ftpServer; }
//        }

//        /// <summary>
//        /// 登陆FTP服务器用户名
//        /// </summary>
//        public string FtpUserName
//        {
//            get { return _ftpUserName; }
//        }

//        /// <summary>
//        /// 登陆FTP服务器密码
//        /// </summary>
//        public string FtpPassword
//        {
//            get { return _ftpPassword; }
//        }

//        /// <summary>
//        /// 登陆超时时间
//        /// </summary>
//        public int FtpTimeout
//        {
//            get { return _ftpTimeOut; }
//        }

//        /// <summary>
//        /// FTP服务器端口号
//        /// </summary>
//        public int FtpPort
//        {
//            get { return _ftpPort; }
//        }

   

//        /// <summary>
//        /// FTP传输模式
//        /// </summary>
//        public string TransferMode
//        {
//            get { return _transferMode; }
//            set { _transferMode = value; }
//        }

//        /// <summary>
//        /// Ftp字符集
//        /// </summary>
//        public string FtpEncoder
//        {
//            get { return string.IsNullOrEmpty(_ftpEncoder) ? "Default" : _ftpEncoder; }
//            set { _ftpEncoder = value; }
//        }

//        /// <summary>
//        /// 附件服务器地址
//        /// </summary>
//        public override string AttachmentServerUrl
//        {
//            get { return _AttachmentServerUrl; }
//        }

//        /// <summary>
//        /// 下载临时目录
//        /// </summary>
//        public string DownLoadTempDir
//        {
//            get { return _downLoadTempDir; }
//            set { _downLoadTempDir = value; }
//        }

//        /// <summary>
//        /// 获取附件的完整物理路径
//        /// </summary>
//        /// <returns></returns>
//        public override string GetAttachmentFullFileAddress()
//        {
//            return "";
//        }

//        /// <summary>
//        /// 删除文件
//        /// </summary>
//        /// <param name="targetCategoryAttachPath">附件的分类路径</param>
//        /// <returns></returns>
//        public override bool DeleteFile(string targetCategoryAttachPath)
//        {
//            if (HasAttachment( targetCategoryAttachPath))
//            {
//                try
//                {
//                    FtpClient client = this.GetFtpClient();
//                    client.DeleteFile(targetCategoryAttachPath);
//                    return true;
//                }
//                catch (Exception ex)
//                {
//                    Logger.LogError("NetworkAttachmentProvider", "DeleteFile", AppError.EROR, 0, ex,
//                                    string.Format("从附件服务器删除文件{0}时出错！", targetCategoryAttachPath), string.Empty);
//                    return false;
//                }

//            }

//            return false;
//        }


      

//        /// <summary>
//        /// 下载文件
//        /// </summary>
//        /// <param name="targetCategoryAttachPath">需要下载的附件路径</param>
//        /// <param name="newFileName">保存文件的文件名</param>
//        public override void DownLoadFile(string targetCategoryAttachPath, string newFileName)
//        {
//            if (HasAttachment(targetCategoryAttachPath))
//            {
//                HttpContext context = HttpContext.Current;
//                if (context != null)
//                {
//                    string fileName = string.IsNullOrEmpty(newFileName) ? Path.GetFileName(targetCategoryAttachPath)
//                                                                        : HttpUtility.UrlEncode(newFileName, Encoding.UTF8);

//                    HttpResponse Response = context.Response;
//                    Response.ContentType = "application/octet-stream";
//                    Response.AppendHeader("Connection", "keep-alive");
//                    Response.AppendHeader("Content-Disposition", string.Format("attachment;filename={0}", fileName));

//                    byte[] b;
//                    using (FileStream fs = GetFile(targetCategoryAttachPath))
//                    {
//                        b = new byte[fs.Length];
//                        fs.Read(b, 0, b.Length);
//                        fs.Close();
//                    }

//                    if (b.Length > 0)
//                    {
//                        Response.BinaryWrite(b);
//                    }

//                    Response.Flush();
//                    Response.End();
//                }
//            }
//        }

//        /// <summary>
//        /// 保存附件
//        /// </summary>
//        /// <param name="sourceFile"></param>
//        /// <param name="targetCategory"></param>
//        /// <param name="fileName"></param>
//        /// <returns></returns>
//        public override string SaveAttach(byte[] sourceFile, string targetCategory, string fileName)
//        {
//            string realCategoryPath = string.Format("{0}/{1}", GenAttachmentRealCategoryDir(targetCategory), fileName);
//            Stream stream = new MemoryStream(sourceFile);
//            SaveToFTP(stream, realCategoryPath);
//            return realCategoryPath;
//        }

//       //该方法还没实现
//       public override bool DownLoadFileToPath(string targetCategoryAttachPath, string path, string newFileName)
//       {
//           return false;
//       }

//        /// <summary>
//        /// 保存附件
//        /// </summary>
//        /// <param name="sourceFilePath">原始文件路径</param>
//        /// <param name="targetCategory">附件的分类文件夹</param>
//        /// <param name="fileName">附件的新的文件名称</param>
//        /// <param name="delSource">复制成功后是否删除原文件</param>
//        /// <returns></returns>
//        public override string SaveAttach(string sourceFilePath, string targetCategory, string fileName, bool delSource)
//        {
//            string realCategoryPath = string.Format("{0}/{1}", GenAttachmentRealCategoryDir(targetCategory), fileName);
//            using (FileStream stream = new FileStream(sourceFilePath, FileMode.Open))
//            {
//                SaveAttach(stream, targetCategory, fileName);
//            }

//            if (delSource)
//                File.Delete(sourceFilePath);

//            return realCategoryPath;
//        }

//        /// <summary>
//        /// 保存附件
//        /// </summary>
//        /// <param name="sourceFile">要上传的附件的流</param>
//        /// <param name="targetCategory">附件的分类文件夹</param>
//        ///  <param name="fileName">附件新名称</param>
//        /// <returns></returns>
//        public override string SaveAttach(Stream sourceFile, string targetCategory, string fileName)
//        {
//            string realCategoryPath = string.Format("{0}/{1}", GenAttachmentRealCategoryDir(targetCategory), fileName);
//            SaveToFTP(sourceFile, realCategoryPath);

//            return realCategoryPath;
//        }


//        private void SaveToFTP(Stream sourceFile, string fullPath)
//        {
//            Encoding ftpEncodingInfo = _ftpEncoder.ToLower()=="default"?Encoding.Default:Encoding.GetEncoding(_ftpEncoder);
//            if (null == ftpEncodingInfo) ftpEncodingInfo = Encoding.Default;
//            FtpClient client = new FtpClient(FtpServer, FtpUserName, FtpPassword, FtpTimeout, FtpPort, ftpEncodingInfo);
//            try
//            {

//                if (!string.IsNullOrEmpty(TransferMode) && TransferMode.ToLower() == "port")
//                {
//                    client.TransferMode = DataTransferMode.Port;
//                }
//                else
//                {
//                    client.TransferMode = DataTransferMode.Pasv;
//                }


//                client.MakeRecursionDir(Path.GetDirectoryName(fullPath));
//                client.Upload(sourceFile, Path.GetFileName(fullPath), true);
//            }
           
//          catch (Exception e)
//            {
//                throw new ApplicationException(string.Format("将文件上传至{0}时出现错误,ftpserver:{1},ftpUsername:{2},FtpPort:{3}ftpEncode:{4},TransferMode:{5}", fullPath,FtpServer,FtpUserName,FtpPort,ftpEncodingInfo.EncodingName,client.TransferMode), e);
//            }

            
//            sourceFile.Close();
//            client.Close();
//        }

//        /// <summary>
//        /// 生成一个将要保存附件的真实分类路径,根据年份和月分进一步分类
//        /// </summary>
//        /// <param name="targetCategory"></param>
//        /// <returns></returns>
//        private static string GenAttachmentRealCategoryDir(string targetCategory)
//        {
//            //if (targetCategory == string.Empty)
//            //    throw new ArgumentException("targetCategory不能为空串，请提供一个分类信息,如: SI/images");

//            //if (targetCategory.StartsWith("/") || targetCategory.StartsWith("\\"))
//            //    throw new ArgumentException("targetCategory不能以/或\\开始");

//            return string.Format("{0}", targetCategory.TrimEnd('/').TrimEnd('\\'));
//        }


//        /// <summary>
//        /// 保存附件(推荐使用),并返回附件服务器上的真实的分类目录
//        /// </summary>
//        /// <param name="postedFile">要保存的附件</param>
//        /// <param name="targetCategory">附件的分类文件夹</param>
//        /// <param name="fileName">附件的新名称</param>
//        /// <returns></returns>
//        public override string SaveAttach(HttpPostedFile postedFile, string targetCategory, string fileName)
//        {
//            string realCategoryPath = string.Format("{0}/{1}", GenAttachmentRealCategoryDir(targetCategory), fileName);

//            using (Stream input = postedFile.InputStream)
//            {
//                SaveToFTP(postedFile.InputStream, realCategoryPath);
//                input.Close();
//            }

//            //postedFile.SaveAs(fullPath);
//            return (realCategoryPath);
//        }

//        /// <summary>
//        /// 获取附件的完整路径
//        /// </summary>
//        /// <param name="categoryPath">附件真实的相对路径</param>
//        /// <returns></returns>
//        public override string GetAttachmentFullUrl(string categoryPath)
//        {
//            return string.Format("{0}/{1}", AttachmentServerUrl, categoryPath);
//        }


//        /// <summary>
//        /// 下载文件到网站本地的Temp目录
//        /// </summary>
//        /// <param name="targetCategoryAttachPath">需要下载的文件路径</param>
//        /// <param name="newFileName"></param>
//        /// <returns></returns>
//        public override bool DownLoadFileToTemp(string targetCategoryAttachPath, string newFileName)
//        {
//            if (HasAttachment(targetCategoryAttachPath))
//            {
//                string tempDir = HttpContext.Current.Server.MapPath(DownLoadTempDir);
//                try
//                {
//                    FtpClient client = this.GetFtpClient();
//                    string path = Path.Combine(tempDir, targetCategoryAttachPath);
//                    string dir = Path.GetDirectoryName(path);
//                    if (!string.IsNullOrEmpty(newFileName))
//                        path = dir + "\\" + newFileName;

//                    client.Download(targetCategoryAttachPath, path, true);
//                    return true;
//                }
//                catch (Exception ex)
//                {
//                    Logger.LogError("FtpAttachmentProvider", "DownLoadFileToTemp", AppError.EROR, 0, ex,
//                                    "从FTP服务器下载文件到网站Temp目录出错", string.Empty);
//                    return false;
//                }
//            }
//            return false;
//        }


//        /// <summary>
//        /// 获取附件服务器上的附件流
//        /// </summary>
//        /// <param name="categoryPath">真实的附件分类目录</param>
//        /// <returns></returns>
//        public override FileStream GetAttachmentFile(string categoryPath)
//        {
//            return DownFromFtp(categoryPath);
//        }


//        //获取一个附件的文件流
//        private FileStream GetFile(string targetCategoryPath)
//        {
//            return DownFromFtp(targetCategoryPath);
//        }


//        private FileStream DownFromFtp(string categoryPath)
//        {
//            string tempDir = HttpContext.Current.Server.MapPath(DownLoadTempDir);
//            FtpClient client = this.GetFtpClient();
//            string path = Path.Combine(tempDir, categoryPath);
//            client.Download(categoryPath, path, true);
//            return new FileStream(path, FileMode.Open);
//        }

//        /// <summary>
//        /// 附件是否存在
//        /// </summary>
//        /// <param name="targetCategoryPath">FTP服务器上的文件路径</param>
//        /// <returns></returns>
//        public override bool HasAttachment(string targetCategoryPath)
//        {
//            #region OldCode

//            //string dir = Path.GetDirectoryName(targetCategoryPath);
//            //string fileName = Path.GetFileName(targetCategoryPath);

//            //FtpClient client = this.GetFtpClient();
//            //string[] files = client.GetFileList(dir);
//            //foreach (string file in files)
//            //{
//            //    if (file.Contains(fileName))
//            //    {
//            //        return true;
//            //        break;
//            //    }
//            //}

//            //return false;

//            #endregion

//            try
//            {
//                FtpClient client = this.GetFtpClient();
//                return client.GetFileSize(targetCategoryPath) > 0;
//            }
//            catch (Exception)
//            {
//                return false;
//            }
//        }

//        /// <summary>
//        /// 获取ftp客户端对象
//        /// </summary>
//        private FtpClient GetFtpClient()
//        {
//            return new FtpClient(FtpServer, FtpUserName, FtpPassword, FtpTimeout, FtpPort);
//        }

//       public override void Initialize(string name, NameValueCollection config)
//       {
//           if (string.IsNullOrEmpty(name))
//               name = "FTPCRMAttachment";

//           if (null == config)
//               throw new ArgumentException("配置参数不能为空");

//           if (string.IsNullOrEmpty(config["description"]))
//           {
//               config.Remove("description");
//               config.Add("description", "通过FTP方式上传附件");
//           }

//           base.Initialize(name, config);

//           GetConfig(config);
//       }

//        public void GetConfig(NameValueCollection config)
//        {
//            //默认构造CRM临时目录服务器地址

//            _ftpServer = ADCSystemSettings.GetADCSystemSettings().CRMFtpServer;
//            _ftpUserName = ADCSystemSettings.GetADCSystemSettings().CRMFtpUser;
//            _ftpPassword = ADCSystemSettings.GetADCSystemSettings().CRMFtppassword;
//            _AttachmentServerUrl = ADCSystemSettings.GetADCSystemSettings().CRMFtpAttachmentServerUrl;
//            _transferMode = ADCSystemSettings.GetADCSystemSettings().CRMFtpTransferModel;
//            _ftpEncoder = ADCSystemSettings.GetADCSystemSettings().CRMFtpEncoder;

//            if (!int.TryParse("21", out _ftpPort))
//                throw new ArgumentException("端口配置错误，端口必需为整型值");

//            if (!int.TryParse("300", out _ftpTimeOut))
//                throw new ArgumentException("超时时长配置错误，超时时长必需为整型值");


//        }

//        public override string SaveAttach(Stream sourceFile, string realCategoryPath)
//        {
//            throw new NotImplementedException();
//        }
//    }
//}
